// 尝试成为主节点
bool NodeManager::tryBecomeLeader() {
    LOG_INFO("尝试成为主节点, 节点ID: " + m_nodeInfo.id);
    
    try {
        // 先检查是否已有主节点
        EtcdResult checkResult = m_etcdClient->get(LEADER_KEY);
        if (checkResult.success && !checkResult.value.empty()) {
            LOG_INFO("已存在主节点: " + checkResult.value + ", 无法成为主节点");
            return false;
        }
        
        // 使用事务确保原子性操作
        EtcdResult result = m_etcdClient->txnCompareAndSwap(
            LEADER_KEY,      // 键
            "",              // 期望的当前值（空表示键不存在或值为空）
            m_nodeInfo.id,   // 要设置的新值
            true             // 比较键是否存在
        );
        
        if (result.success) {
            LOG_INFO("成功成为主节点: " + m_nodeInfo.id);
            
            // 更新节点状态
            m_nodeInfo.status = NodeStatus::LEADER;
            m_nodeInfo.lastStatusChange = std::chrono::system_clock::now();
            
            // 序列化并保存节点信息
            std::string serializedInfo = serializeNodeInfo(m_nodeInfo);
            EtcdResult updateResult = m_etcdClient->put(NODE_PREFIX + m_nodeInfo.id, serializedInfo);
            
            if (!updateResult.success) {
                LOG_WARNING("保存主节点状态失败: " + updateResult.errorMessage);
            }
            
            return true;
        } else {
            LOG_INFO("无法成为主节点: " + result.errorMessage);
            return false;
        }
    } catch (const std::exception& e) {
        LOG_ERROR("尝试成为主节点异常: " + std::string(e.what()));
        return false;
    }
}

void NodeManager::checkLeaderHealth(const std::string& leaderId) {
    LOG_DEBUG("检查主节点健康状态: " + leaderId);
    
    try {
        // 获取主节点信息
        EtcdResult result = m_etcdClient->get(NODE_PREFIX + leaderId);
        if (!result.success || result.value.empty()) {
            LOG_WARNING("获取主节点信息失败: " + 
                       (result.success ? "信息为空" : result.errorMessage));
            
            // 删除主节点键，触发重新选举
            LOG_INFO("触发重新选举，删除当前主节点键");
            m_etcdClient->del(LEADER_KEY);
            return;
        }
        
        // 解析主节点信息
        NodeInfo leaderInfo;
        if (!deserializeNodeInfo(result.value, leaderInfo)) {
            LOG_WARNING("解析主节点信息失败: " + result.value);
            
            // 删除主节点键，触发重新选举
            LOG_INFO("触发重新选举，删除当前主节点键");
            m_etcdClient->del(LEADER_KEY);
            return;
        }
        
        // 检查主节点状态
        if (leaderInfo.status != NodeStatus::LEADER) {
            LOG_WARNING("主节点状态不正确: " + nodeStatusToString(leaderInfo.status));
            
            // 删除主节点键，触发重新选举
            LOG_INFO("触发重新选举，删除当前主节点键");
            m_etcdClient->del(LEADER_KEY);
            return;
        }
        
        // 检查主节点心跳
        auto now = std::chrono::system_clock::now();
        auto heartbeatAge = std::chrono::duration_cast<std::chrono::seconds>(
            now - leaderInfo.lastHeartbeat).count();
        
        if (heartbeatAge > LEASE_TTL / 2) {
            LOG_WARNING("主节点心跳超时: " + std::to_string(heartbeatAge) + "秒");
            
            // 删除主节点键，触发重新选举
            LOG_INFO("触发重新选举，删除当前主节点键");
            m_etcdClient->del(LEADER_KEY);
            return;
        }
        
        LOG_DEBUG("主节点健康");
    } catch (const std::exception& e) {
        LOG_ERROR("检查主节点健康状态异常: " + std::string(e.what()));
    }
}

NodeInfo NodeManager::getLeaderNode() const {
    LOG_DEBUG("获取主节点");
    
    NodeInfo leader;
    leader.status = NodeStatus::UNKNOWN;
    
    try {
        EtcdResult result = m_etcdClient->get(LEADER_KEY);
        if (!result.success) {
            LOG_WARNING("获取主节点信息失败: " + result.errorMessage);
            return leader;
        }

        std::string leaderId = result.value;
        if (leaderId.empty()) {
            LOG_INFO("当前没有主节点");
            return leader;
        }

        LOG_INFO("当前主节点ID: " + leaderId);
        
        // 获取主节点详细信息
        EtcdResult nodeResult = m_etcdClient->get(NODE_PREFIX + leaderId);
        if (!nodeResult.success || nodeResult.value.empty()) {
            LOG_WARNING("获取主节点详细信息失败: " + 
                        (nodeResult.success ? "节点信息为空" : nodeResult.errorMessage));
            return leader;
        }
        
        // 解析节点信息
        if (!deserializeNodeInfo(nodeResult.value, leader)) {
            LOG_WARNING("解析主节点信息失败: " + nodeResult.value);
        } else {
            LOG_DEBUG("成功获取主节点信息: id=" + leader.id + ", status=" + nodeStatusToString(leader.status));
        }
    } catch (const std::exception& e) {
        LOG_ERROR("获取主节点异常: " + std::string(e.what()));
    }
    
    return leader;
}

void NodeManager::electionLoop() {
    LOG_INFO("启动选举线程: 节点ID=" + m_nodeInfo.id);
    
    // 随机化选举延迟，避免选举风暴
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1000, 3000); // 1-3秒的随机延迟
    
    while (m_running) {
        try {
            // 如果节点状态为故障，等待一段时间后继续
            if (m_nodeInfo.status == NodeStatus::FAULT) {
                std::this_thread::sleep_for(std::chrono::milliseconds(ELECTION_INTERVAL_MS));
                continue;
            }
            
            // 检查是否已存在主节点
            NodeInfo leader = getLeaderNode();
            
            if (leader.status == NodeStatus::LEADER) {
                LOG_DEBUG("主节点存在: " + leader.id);
                
                // 如果自己是主节点，检查是否需要放弃主节点地位
                if (leader.id == m_nodeInfo.id) {
                    if (m_nodeInfo.status != NodeStatus::LEADER) {
                        LOG_WARNING("当前节点(" + m_nodeInfo.id + ")是主节点但状态不一致，更新状态");
                        m_nodeInfo.status = NodeStatus::LEADER;
                        updateNodeInfo();
                    }
                } 
                // 如果自己不是主节点，检查主节点健康状况
                else {
                    if (m_nodeInfo.status == NodeStatus::LEADER) {
                        LOG_WARNING("当前节点(" + m_nodeInfo.id + ")不是主节点但状态为LEADER，更新为FOLLOWER");
                        m_nodeInfo.status = NodeStatus::FOLLOWER;
                        updateNodeInfo();
                    }
                    
                    // 检查主节点健康状况
                    checkLeaderHealth(leader.id);
                }
            } 
            // 没有主节点，尝试成为主节点
            else {
                LOG_INFO("没有主节点，等待随机延迟后尝试成为主节点");
                
                // 随机延迟，避免选举冲突
                std::this_thread::sleep_for(std::chrono::milliseconds(dis(gen)));
                
                // 再次检查，确保延迟期间没有其他节点成为主节点
                NodeInfo checkLeader = getLeaderNode();
                if (checkLeader.status != NodeStatus::LEADER) {
                    LOG_INFO("尝试成为主节点");
                    if (tryBecomeLeader()) {
                        LOG_INFO("成功成为主节点");
                    } else {
                        LOG_INFO("未能成为主节点，等待下次尝试");
                    }
                }
            }
            
            // 选举检查间隔
            std::this_thread::sleep_for(std::chrono::milliseconds(ELECTION_INTERVAL_MS));
        } catch (const std::exception& e) {
            LOG_ERROR("选举线程异常: " + std::string(e.what()));
            std::this_thread::sleep_for(std::chrono::milliseconds(ELECTION_INTERVAL_MS));
        }
    }
    
    LOG_INFO("选举线程结束: 节点ID=" + m_nodeInfo.id);
}

void NodeManager::updateNodeInfo() {
    LOG_DEBUG("更新节点信息: id=" + m_nodeInfo.id + ", status=" + nodeStatusToString(m_nodeInfo.status));
    
    try {
        // 更新节点的最后心跳时间
        m_nodeInfo.lastHeartbeat = std::chrono::system_clock::now();
        
        // 序列化节点信息
        std::string serializedInfo = serializeNodeInfo(m_nodeInfo);
        
        // 保存到ETCD
        EtcdResult result = m_etcdClient->put(NODE_PREFIX + m_nodeInfo.id, serializedInfo, m_leaseId);
        
        if (!result.success) {
            LOG_WARNING("更新节点信息失败: " + result.errorMessage);
        }
    } catch (const std::exception& e) {
        LOG_ERROR("更新节点信息异常: " + std::string(e.what()));
    }
}

std::string NodeManager::nodeStatusToString(NodeStatus status) const {
    switch (status) {
        case NodeStatus::UNKNOWN:
            return "UNKNOWN";
        case NodeStatus::STARTING:
            return "STARTING";
        case NodeStatus::FOLLOWER:
            return "FOLLOWER";
        case NodeStatus::LEADER:
            return "LEADER";
        case NodeStatus::FAULT:
            return "FAULT";
        default:
            return "INVALID";
    }
} 